
/*
** Auxiliary functions for building Lua libraries
** See Copyright Notice in lua.h
*/

#include <ctype.h>
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>

/* This file uses only the official API of Lua.
** Any function declared here could be written as an application function.
*/

#define lauxlib_c

#include "lua.h"

#include "lauxlib.h"

/* number of prereserved references (for internal use) */
#define RESERVED_REFS	2

/* reserved references */
#define FREELIST_REF	1       /* free list of references */
#define ARRAYSIZE_REF	2       /* array sizes */

/* convert a stack index to positive */
#define abs_index(L, i)		((i) > 0 || (i) <= LUA_REGISTRYINDEX ? (i) : \
					lua_gettop(L) + (i) + 1)

/*
** {======================================================
** Error-report functions
** =======================================================
*/

LUALIB_API int
luaL_argerror(lua_State * L, int narg, const char *extramsg)
{
  lua_Debug ar;
  lua_getstack(L, 0, &ar);
  lua_getinfo(L, "n", &ar);
  if (strcmp(ar.namewhat, "method") == 0) {
    narg--;                     /* do not count `self' */
    if (narg == 0)              /* error is in the self argument itself? */
      luaL_error(L, "calling `%s' on bad self (%s)", ar.name, extramsg);
  }
  if (ar.name == NULL)
    ar.name = "?";
  luaL_error(L, "bad argument #%d to `%s' (%s)", narg, ar.name, extramsg);
}

LUALIB_API int
luaL_typerror(lua_State * L, int narg, const char *tname)
{
  const char *msg = lua_pushfstring(L, "%s expected, got %s",
                                    tname, lua_typename(L,
                                                        lua_type(L,
                                                                 narg)));
  luaL_argerror(L, narg, msg);
}

static void tag_error(lua_State * L, int narg, int tag) __attribute__ ((noreturn));
static void
tag_error(lua_State * L, int narg, int tag)
{
  luaL_typerror(L, narg, lua_typename(L, tag));
}

LUALIB_API void
luaL_where(lua_State * L, int level)
{
  lua_Debug ar;
  if (lua_getstack(L, level, &ar)) {    /* check function at level */
    lua_getinfo(L, "Snl", &ar); /* get info about it */
    if (ar.currentline > 0) {   /* is there info? */
      lua_pushfstring(L, "%s:%d: ", ar.short_src, ar.currentline);
      return;
    }
  }
  lua_pushliteral(L, "");       /* else, no information available... */
}

LUALIB_API int
luaL_error(lua_State * L, const char *fmt, ...)
{
  va_list argp;
  va_start(argp, fmt);
  luaL_where(L, 1);
  lua_pushvfstring(L, fmt, argp);
  va_end(argp);
  lua_concat(L, 2);
  lua_error(L);
}

/* }====================================================== */

LUALIB_API int
luaL_findstring(const char *name, const char *const list[])
{
  int i;
  for (i = 0; list[i]; i++)
    if (strcmp(list[i], name) == 0)
      return i;
  return -1;                    /* name not found */
}

LUALIB_API int
luaL_newmetatable(lua_State * L, const char *tname)
{
  lua_pushstring(L, tname);
  lua_rawget(L, LUA_REGISTRYINDEX);     /* get registry.name */
  if (!lua_isnil(L, -1))        /* name already in use? */
    return 0;                   /* leave previous value on top, but return 0 */
  lua_pop(L, 1);
  lua_newtable(L);              /* create metatable */
  lua_pushstring(L, tname);
  lua_pushvalue(L, -2);
  lua_rawset(L, LUA_REGISTRYINDEX);     /* registry.name = metatable */
  lua_pushvalue(L, -1);
  lua_pushstring(L, tname);
  lua_rawset(L, LUA_REGISTRYINDEX);     /* registry[metatable] = name */
  return 1;
}

LUALIB_API void
luaL_getmetatable(lua_State * L, const char *tname)
{
  lua_pushstring(L, tname);
  lua_rawget(L, LUA_REGISTRYINDEX);
}

LUALIB_API void *
luaL_checkudata(lua_State * L, int ud, const char *tname)
{
  const char *tn;
  if (!lua_getmetatable(L, ud))
    return NULL;                /* no metatable? */
  lua_rawget(L, LUA_REGISTRYINDEX);     /* get registry[metatable] */
  tn = lua_tostring(L, -1);
  if (tn && (strcmp(tn, tname) == 0)) {
    lua_pop(L, 1);
    return lua_touserdata(L, ud);
  } else {
    lua_pop(L, 1);
    return NULL;
  }
}

LUALIB_API void
luaL_checkstack(lua_State * L, int space, const char *mes)
{
  if (!lua_checkstack(L, space))
    luaL_error(L, "stack overflow (%s)", mes);
}

LUALIB_API void
luaL_checktype(lua_State * L, int narg, int t)
{
  if (lua_type(L, narg) != t)
    tag_error(L, narg, t);
}

LUALIB_API void
luaL_checkany(lua_State * L, int narg)
{
  if (lua_type(L, narg) == LUA_TNONE)
    luaL_argerror(L, narg, "value expected");
}

LUALIB_API const char *
luaL_checklstring(lua_State * L, int narg, size_t * len)
{
  const char *s = lua_tostring(L, narg);
  if (!s)
    tag_error(L, narg, LUA_TSTRING);
  if (len)
    *len = lua_strlen(L, narg);
  return s;
}

LUALIB_API const char *
luaL_optlstring(lua_State * L, int narg, const char *def, size_t * len)
{
  if (lua_isnoneornil(L, narg)) {
    if (len)
      *len = (def ? strlen(def) : 0);
    return def;
  } else
    return luaL_checklstring(L, narg, len);
}

LUALIB_API lua_Number
luaL_checknumber(lua_State * L, int narg)
{
  lua_Number d = lua_tonumber(L, narg);
  if (d == 0 && !lua_isnumber(L, narg)) /* avoid extra test when d is not 0 */
    tag_error(L, narg, LUA_TNUMBER);
  return d;
}

LUALIB_API lua_Number
luaL_optnumber(lua_State * L, int narg, lua_Number def)
{
  if (lua_isnoneornil(L, narg))
    return def;
  else
    return luaL_checknumber(L, narg);
}

LUALIB_API int
luaL_getmetafield(lua_State * L, int obj, const char *event)
{
  if (!lua_getmetatable(L, obj))        /* no metatable? */
    return 0;
  lua_pushstring(L, event);
  lua_rawget(L, -2);
  if (lua_isnil(L, -1)) {
    lua_pop(L, 2);              /* remove metatable and metafield */
    return 0;
  } else {
    lua_remove(L, -2);          /* remove only metatable */
    return 1;
  }
}

LUALIB_API int
luaL_callmeta(lua_State * L, int obj, const char *event)
{
  obj = abs_index(L, obj);
  if (!luaL_getmetafield(L, obj, event))        /* no metafield? */
    return 0;
  lua_pushvalue(L, obj);
  lua_call(L, 1, 1);
  return 1;
}

LUALIB_API void
luaL_openlib(lua_State * L, const char *libname, const luaL_reg * l, int nup)
{
  if (libname) {
    lua_pushstring(L, libname);
    lua_gettable(L, LUA_GLOBALSINDEX);  /* check whether lib already exists */
    if (lua_isnil(L, -1)) {     /* no? */
      lua_pop(L, 1);
      lua_newtable(L);          /* create it */
      lua_pushstring(L, libname);
      lua_pushvalue(L, -2);
      lua_settable(L, LUA_GLOBALSINDEX);        /* register it with given name */
    }
    lua_insert(L, -(nup + 1));  /* move library table to below upvalues */
  }
  for (; l->name; l++) {
    int i;
    lua_pushstring(L, l->name);
    for (i = 0; i < nup; i++)   /* copy upvalues to the top */
      lua_pushvalue(L, -(nup + 1));
    lua_pushcclosure(L, l->func, nup);
    lua_settable(L, -(nup + 3));
  }
  lua_pop(L, nup);              /* remove upvalues */
}

/*
** {======================================================
** getn-setn: size for arrays
** =======================================================
*/

static int
checkint(lua_State * L, int topop)
{
  int n = lua_tonumber(L, -1);
  if (n == 0 && !lua_isnumber(L, -1))
    n = -1;
  lua_pop(L, topop);
  return n;
}

static void
getsizes(lua_State * L)
{
  lua_rawgeti(L, LUA_REGISTRYINDEX, ARRAYSIZE_REF);
  if (lua_isnil(L, -1)) {       /* no `size' table? */
    lua_pop(L, 1);              /* remove nil */
    lua_newtable(L);            /* create it */
    lua_pushvalue(L, -1);       /* `size' will be its own metatable */
    lua_setmetatable(L, -2);
    lua_pushliteral(L, "__mode");
    lua_pushliteral(L, "k");
    lua_rawset(L, -3);          /* metatable(N).__mode = "k" */
    lua_pushvalue(L, -1);
    lua_rawseti(L, LUA_REGISTRYINDEX, ARRAYSIZE_REF);   /* store in register */
  }
}

void
luaL_setn(lua_State * L, int t, int n)
{
  t = abs_index(L, t);
  lua_pushliteral(L, "n");
  lua_rawget(L, t);
  if (checkint(L, 1) >= 0) {    /* is there a numeric field `n'? */
    lua_pushliteral(L, "n");    /* use it */
    lua_pushnumber(L, (lua_Number) n);
    lua_rawset(L, t);
  } else {                      /* use `sizes' */
    getsizes(L);
    lua_pushvalue(L, t);
    lua_pushnumber(L, (lua_Number) n);
    lua_rawset(L, -3);          /* sizes[t] = n */
    lua_pop(L, 1);              /* remove `sizes' */
  }
}

int
luaL_getn(lua_State * L, int t)
{
  int n;
  t = abs_index(L, t);
  lua_pushliteral(L, "n");      /* try t.n */
  lua_rawget(L, t);
  if ((n = checkint(L, 1)) >= 0)
    return n;
  getsizes(L);                  /* else try sizes[t] */
  lua_pushvalue(L, t);
  lua_rawget(L, -2);
  if ((n = checkint(L, 2)) >= 0)
    return n;
  for (n = 1;; n++) {           /* else must count elements */
    lua_rawgeti(L, t, n);
    if (lua_isnil(L, -1))
      break;
    lua_pop(L, 1);
  }
  lua_pop(L, 1);
  return n - 1;
}

/* }====================================================== */

/*
** {======================================================
** Generic Buffer manipulation
** =======================================================
*/

#define bufflen(B)	((B)->p - (B)->buffer)
#define bufffree(B)	((size_t)(LUAL_BUFFERSIZE - bufflen(B)))

#define LIMIT	(LUA_MINSTACK/2)

static int
emptybuffer(luaL_Buffer * B)
{
  size_t l = bufflen(B);
  if (l == 0)
    return 0;                   /* put nothing on stack */
  else {
    lua_pushlstring(B->L, B->buffer, l);
    B->p = B->buffer;
    B->lvl++;
    return 1;
  }
}

static void
adjuststack(luaL_Buffer * B)
{
  if (B->lvl > 1) {
    lua_State *L = B->L;
    int toget = 1;                     /* number of levels to concat */
    size_t toplen = lua_strlen(L, -1);
    do {
      size_t l = lua_strlen(L, -(toget + 1));
      if (B->lvl - toget + 1 >= LIMIT || toplen > l) {
        toplen += l;
        toget++;
      } else
        break;
    }
    while (toget < B->lvl);
    lua_concat(L, toget);
    B->lvl = B->lvl - toget + 1;
  }
}

LUALIB_API char *
luaL_prepbuffer(luaL_Buffer * B)
{
  if (emptybuffer(B))
    adjuststack(B);
  return B->buffer;
}

LUALIB_API void
luaL_addlstring(luaL_Buffer * B, const char *s, size_t l)
{
  while (l--)
    luaL_putchar(B, *s++);
}

LUALIB_API void
luaL_addstring(luaL_Buffer * B, const char *s)
{
  luaL_addlstring(B, s, strlen(s));
}

LUALIB_API void
luaL_pushresult(luaL_Buffer * B)
{
  emptybuffer(B);
  lua_concat(B->L, B->lvl);
  B->lvl = 1;
}

LUALIB_API void
luaL_addvalue(luaL_Buffer * B)
{
  lua_State *L = B->L;
  size_t vl = lua_strlen(L, -1);
  if (vl <= bufffree(B)) {      /* fit into buffer? */
    memcpy(B->p, lua_tostring(L, -1), vl);      /* put it there */
    B->p += vl;
    lua_pop(L, 1);              /* remove from stack */
  } else {
    if (emptybuffer(B))
      lua_insert(L, -2);        /* put buffer before new value */
    B->lvl++;                   /* add new value into B stack */
    adjuststack(B);
  }
}

LUALIB_API void
luaL_buffinit(lua_State * L, luaL_Buffer * B)
{
  B->L = L;
  B->p = B->buffer;
  B->lvl = 0;
}

/* }====================================================== */

LUALIB_API int
luaL_ref(lua_State * L, int t)
{
  int ref;
  t = abs_index(L, t);
  if (lua_isnil(L, -1)) {
    lua_pop(L, 1);              /* remove from stack */
    return LUA_REFNIL;          /* `nil' has a unique fixed reference */
  }
  lua_rawgeti(L, t, FREELIST_REF);      /* get first free element */
  ref = lua_tonumber(L, -1);    /* ref = t[FREELIST_REF] */
  lua_pop(L, 1);                /* remove it from stack */
  if (ref != 0) {               /* any free element? */
    lua_rawgeti(L, t, ref);     /* remove it from list */
    lua_rawseti(L, t, FREELIST_REF);    /* (t[FREELIST_REF] = t[ref]) */
  } else {                      /* no free elements */
    ref = luaL_getn(L, t);
    if (ref < RESERVED_REFS)
      ref = RESERVED_REFS;      /* skip reserved references */
    ref++;                      /* create new reference */
    luaL_setn(L, t, ref);
  }
  lua_rawseti(L, t, ref);
  return ref;
}

LUALIB_API void
luaL_unref(lua_State * L, int t, int ref)
{
  if (ref >= 0) {
    t = abs_index(L, t);
    lua_rawgeti(L, t, FREELIST_REF);
    lua_rawseti(L, t, ref);     /* t[ref] = t[FREELIST_REF] */
    lua_pushnumber(L, (lua_Number) ref);
    lua_rawseti(L, t, FREELIST_REF);    /* t[FREELIST_REF] = ref */
  }
}

/*
** {======================================================
** Load functions
** =======================================================
*/

typedef struct LoadF {
  FILE *f;
  char buff[LUAL_BUFFERSIZE];
} LoadF;

static const char *
getF(lua_State * L, void *ud, size_t * size)
{
  LoadF *lf = (LoadF *) ud;
  (void)L;
  if (feof(lf->f))
    return NULL;
  *size = fread(lf->buff, 1, LUAL_BUFFERSIZE, lf->f);
  return (*size > 0) ? lf->buff : NULL;
}

static int
errfile(lua_State * L, int fnameindex)
{
  const char *filename = lua_tostring(L, fnameindex) + 1;
  lua_pushfstring(L, "cannot read %s: %s", filename, strerror(errno));
  lua_remove(L, fnameindex);
  return LUA_ERRFILE;
}

LUALIB_API int
luaL_loadfile(lua_State * L, const char *filename)
{
  LoadF lf;
  int status, readstatus;
  int c;
  int fnameindex = lua_gettop(L) + 1;  /* index of filename on the stack */
  if (filename == NULL) {
    lua_pushliteral(L, "=stdin");
    lf.f = stdin;
  } else {
    lua_pushfstring(L, "@%s", filename);
    lf.f = fopen(filename, "r");
  }
  if (lf.f == NULL)
    return errfile(L, fnameindex);      /* unable to open file */
  c = ungetc(getc(lf.f), lf.f);
  if (!(isspace(c) || isprint(c)) && lf.f != stdin) {   /* binary file? */
    fclose(lf.f);
    lf.f = fopen(filename, "rb");       /* reopen in binary mode */
    if (lf.f == NULL)
      return errfile(L, fnameindex);    /* unable to reopen file */
  }
  status = lua_load(L, getF, &lf, lua_tostring(L, -1));
  readstatus = ferror(lf.f);
  if (lf.f != stdin)
    fclose(lf.f);               /* close file (even in case of errors) */
  if (readstatus) {
    lua_settop(L, fnameindex);  /* ignore results from `lua_load' */
    return errfile(L, fnameindex);
  }
  lua_remove(L, fnameindex);
  return status;
}

typedef struct LoadS {
  const char *s;
  size_t size;
} LoadS;

static const char *
getS(lua_State * L, void *ud, size_t * size)
{
  LoadS *ls = (LoadS *) ud;
  (void)L;
  if (ls->size == 0)
    return NULL;
  *size = ls->size;
  ls->size = 0;
  return ls->s;
}

LUALIB_API int
luaL_loadbuffer(lua_State * L, const char *buff, size_t size, const char *name)
{
  LoadS ls;
  ls.s = buff;
  ls.size = size;
  return lua_load(L, getS, &ls, name);
}

/* }====================================================== */

/*
** {======================================================
** compatibility code
** =======================================================
*/

static void
callalert(lua_State * L, int status)
{
  if (status != 0) {
    lua_getglobal(L, "_ALERT");
    if (lua_isfunction(L, -1)) {
      lua_insert(L, -2);
      lua_call(L, 1, 0);
    } else {                    /* no _ALERT function; print it on stderr */
      fprintf(stderr, "%s\n", lua_tostring(L, -2));
      lua_pop(L, 2);            /* remove error message and _ALERT */
    }
  }
}

static int
aux_do(lua_State * L, int status)
{
  if (status == 0) {            /* parse OK? */
    status = lua_pcall(L, 0, LUA_MULTRET, 0);   /* call main */
  }
  callalert(L, status);
  return status;
}

LUALIB_API int
lua_dofile(lua_State * L, const char *filename)
{
  return aux_do(L, luaL_loadfile(L, filename));
}

LUALIB_API int
lua_dobuffer(lua_State * L, const char *buff, size_t size, const char *name)
{
  return aux_do(L, luaL_loadbuffer(L, buff, size, name));
}

LUALIB_API int
lua_dostring(lua_State * L, const char *str)
{
  return lua_dobuffer(L, str, strlen(str), str);
}

/* }====================================================== */

/*
 * Local Variables:
 * c-basic-offset: 2
 * indent-tabs-mode: nil
 * End:
 */
